import dolphin
import time
import torch
import os
import tempfile
import requests
import argparse
from fastapi import APIRouter, HTTPException, UploadFile, File, Form
from pydantic import BaseModel

# 这里不再直接导入global_punc_model
from config import *

try:
    import zhconv
except ImportError:
    print("警告: 未找到zhconv库，正在尝试安装...")
    try:
        import subprocess
        subprocess.check_call(["pip", "install", "zhconv"])
        import zhconv
        print("zhconv库安装成功！")
    except Exception as e:
        print(f"安装zhconv库失败: {str(e)}")
        print("将无法进行繁体到简体的转换")
        zhconv = None

# 创建路由器
dolphin_router = APIRouter(
    tags=["asr"],
    responses={404: {"description": "Not found"}}
)

# 文件上传响应模型
class ASRFileResponse(BaseModel):
    text: str
    duration: float
    filename: str

# 自动语言检测响应模型
class ASRAutoLangResponse(BaseModel):
    text: str
    duration: float
    filename: str
    detected_language: str

# 语言支持列表
# from .languages import LANGUAGE_REGION_CODES, LANGUAGE_CODES

# 全局变量存储加载的模型
_global_dolphin_model = None

# 实现去除<>以及中括号内的内容
import re

def remove_brackets_and_content(text, brackets="<>[]"):
    """
    去除文本中指定括号及其内容
    
    Args:
        text (str): 输入文本
        brackets (str): 要处理的括号类型，默认为 "<>[]"
    
    Returns:
        str: 处理后的文本
    调用：# 测试
text = "这是一个测试文本，包含<html>标签和 [列表] 内容。"
processed_text = remove_brackets_and_content(text)
print(processed_text)
    """
    if not text:
        return text
    
    # 处理 < > 及其内容
    if '<' in brackets and '>' in brackets:
        text = re.sub(r'<.*?>', '', text)
    
    # 处理 [ ] 及其内容
    if '[' in brackets and ']' in brackets:
        text = re.sub(r'\[.*?\]', '', text)
    
    return text


def convert_traditional_to_simplified(text):
    """
    将繁体中文转换为简体中文
    
    参数:
        text: 待转换的文本
    
    返回:
        转换后的文本
    """
    if zhconv is not None:
        return zhconv.convert(text, 'zh-cn')
    return text  # 如果zhconv不可用，返回原文本

def load_model_once(model_name="small", model_path="./models/dolphin-small", device="cuda"):
    """
    加载模型并保存为全局变量，避免重复加载
    
    参数:
        model_name: 模型名称，默认为"small"
        model_path: 模型路径，默认为"./models/dolphin-small"
        device: 推理设备，"cuda"或"cpu"
    
    返回:
        model: 加载的模型
    """
    global _global_dolphin_model
    
    # 检查CUDA是否可用
    if device == "cuda" and not torch.cuda.is_available():
        print("警告: CUDA不可用，切换到CPU")
        device = "cpu"
        
    # 如果模型尚未加载，则加载模型
    if _global_dolphin_model is None:
        start_time = time.time()
        print("首次加载模型...")
        _global_dolphin_model = dolphin.load_model(model_name, model_path, device)
        end_time = time.time()
        print(f"模型加载耗时: {end_time - start_time:.4f} 秒")
    else:
        print("使用已加载的模型...")
        
    return _global_dolphin_model

def dolphin_asr(audio_path, lang_sym="zh", device="cuda"):
    """
    使用Dolphin ASR进行语音识别
    
    参数:
        audio_path: 音频文件路径
        lang_sym: 语言代码，默认为"zh"（中文）
        device: 推理设备，"cuda"或"cpu"，如果cuda不可用则自动切换为cpu
    
    返回:
        result: 识别结果对象
        metrics: 包含各步骤执行时间的字典
    """
    metrics = {}
    print("开始执行...")
    total_start_time = time.time()
    
    # 检查CUDA是否可用
    if device == "cuda" and not torch.cuda.is_available():
        print("警告: CUDA不可用，切换到CPU")
        device = "cpu"
    
    # 加载音频
    audio_load_start_time = time.time()
    waveform = dolphin.load_audio(audio_path)
    audio_load_end_time = time.time()
    audio_load_time = audio_load_end_time - audio_load_start_time
    metrics["audio_load_time"] = audio_load_time
    print(f"音频加载耗时: {audio_load_time:.4f} 秒")
    
    # 加载模型（使用全局模型避免重复加载）
    model_load_start_time = time.time()
    model = load_model_once(device=device)
    model_load_end_time = time.time()
    model_load_time = model_load_end_time - model_load_start_time
    metrics["model_load_time"] = model_load_time
    print(f"模型获取耗时: {model_load_time:.4f} 秒")
    
    # 推理过程
    inference_start_time = time.time()
    result = model(waveform, lang_sym=lang_sym)
    inference_end_time = time.time()
    inference_time = inference_end_time - inference_start_time
    metrics["inference_time"] = inference_time
    print(f"推理耗时: {inference_time:.4f} 秒")
    
    # 繁体转简体（如果是中文）
    if lang_sym == "zh":
        result.text = convert_traditional_to_simplified(result.text)
    
    # 打印结果
    print("识别结果:", result.text)
    
    # 统计总耗时
    total_end_time = time.time()
    total_time = total_end_time - total_start_time
    metrics["total_time"] = total_time
    print(f"总耗时: {total_time:.4f} 秒")
    
    return result, metrics

def test_dolphin_asr():
    """
    测试Dolphin ASR的识别能力
    """
    # 测试中文识别
    print("test_dolphin_asr...")
    audio_path = "D:/ProjectWorkspace/PythonProjects2/python-utils-project/input_files/英语语音/61-70968-0000.flac"
    # dolphin_asr(audio_path,lang_sym="en")
    waveform = dolphin.load_audio(audio_path)
    model = dolphin.load_model("small", "models/dolphin-small", "cuda")
    result = model(waveform)
    # Specify language and region
    result = model(waveform)#, lang_sym="zh", region_sym="CN"
    result=model(waveform,lang_sym="en")
    print(result.text)
    

def stream_asr(audio_chunk, model=None, lang_sym="zh", device="cuda"):
    """
    流式实时语音识别函数
    
    参数:
        audio_chunk: 音频数据块，可以是文件路径或已加载的音频数据
        model: 预加载的模型，如果为None则使用全局模型
        lang_sym: 语言代码，默认为"zh"（中文）
        device: 推理设备，"cuda"或"cpu"
    
    返回:
        result: 识别结果
        inference_time: 推理耗时
    """
    # 使用全局模型或者传入的模型
    if model is None:
        model = load_model_once(device=device)
    
    # 如果是文件路径，则加载音频
    if isinstance(audio_chunk, str):
        audio_data = dolphin.load_audio(audio_chunk)
    else:
        audio_data = audio_chunk
    
    # 推理
    start_time = time.time()
    result = model(audio_data, lang_sym=lang_sym)
    end_time = time.time()
    inference_time = end_time - start_time
    
    # 繁体转简体（如果是中文）
    if lang_sym == "zh":
        result.text = convert_traditional_to_simplified(result.text)
    # 断句引入-websocket会调用
    if asr_use_punc_model:
        import punc_restore
        result.text = punc_restore.text_punc_restore(result.text)
        
    
    return result, inference_time

def demo_stream_asr():
    """
    流式识别演示函数，模拟实时音频输入
    """
    print("模拟流式识别...")
    # 预加载模型
    model = load_model_once()
    
    # 模拟多个音频块的处理
    audio_files = [
        "input_files/sichuan_dialet/000002.wav",
        # 可以添加更多测试音频文件
    ]
    
    for i, audio_file in enumerate(audio_files):
        print(f"\n处理音频块 {i+1}:")
        result, inference_time = stream_asr(audio_file, model=model)
        print(f"音频块 {i+1} 识别结果: {result.text}")
        print(f"音频块 {i+1} 推理耗时: {inference_time:.4f} 秒")

# ====================== API路由 ======================

@dolphin_router.get("")
def read_root():
    """API根路径，返回欢迎信息"""
    return {
        "message": "欢迎使用Dolphin ASR API服务",
        "status": "运行中",
        "endpoints": {
            "上传音频识别": "/asr-api/asr2",
        }
    }


@dolphin_router.post("/asr2", response_model=ASRFileResponse)
async def recognize_uploaded_file(
    audio_file: UploadFile = File(...),
    lang_sym: str = Form("zh"),
    device: str = Form("cuda")
):
    """
    通过文件上传进行语音识别
    
    参数:
        audio_file: 上传的音频文件
        lang_sym: 语言代码，默认为"zh"（中文）
        device: 推理设备，默认为"cuda"
        
    返回:
        识别结果和处理时间信息
    """
    global _global_dolphin_model
    
    # 检查文件类型（可选，根据需要调整支持的格式）
    allowed_formats = [".wav", ".mp3", ".flac", ".ogg", ".m4a"]
    file_ext = os.path.splitext(audio_file.filename)[1].lower()
    
    if file_ext not in allowed_formats:
        raise HTTPException(
            status_code=400, 
            detail=f"不支持的音频格式: {file_ext}。支持的格式: {', '.join(allowed_formats)}"
        )
    
    try:
        # 创建临时文件以保存上传的音频
        with tempfile.NamedTemporaryFile(delete=False, suffix=file_ext) as temp_file:
            # 将上传的文件内容写入临时文件
            content = await audio_file.read()
            temp_file.write(content)
            temp_path = temp_file.name
        
        # 计时开始
        start_time = time.time()
        
        # 使用临时文件路径进行识别
        result, inference_time = stream_asr(
            temp_path, 
            model=_global_dolphin_model, 
            lang_sym=lang_sym, 
            device=device
        )
        
        # 计算总处理时间
        total_time = time.time() - start_time
        # 去除<>[]及其内容
        text_result = remove_brackets_and_content(result.text)
        
        try:
            # 结果预处理-分词断句，明确使用全局预加载的模型
            if asr_use_punc_model:
                # 在这里导入punc_restore模块
                import punc_restore
                text_result = punc_restore.text_punc_restore(text_result)
                print("标点恢复处理完成")
        except Exception as e:
            print(f"标点恢复处理失败: {str(e)}，使用原始文本")
            text_result = result.text  # 如果标点恢复失败，使用原始文本
        
        # 返回结果
        response = {
            "text": text_result,
            "duration": total_time,
            "filename": audio_file.filename
        }
        
        # 删除临时文件
        os.unlink(temp_path)
        
        return response
    
    except Exception as e:
        # 确保出错时也删除临时文件
        if 'temp_path' in locals():
            try:
                os.unlink(temp_path)
            except:
                pass
        
        raise HTTPException(status_code=500, detail=f"识别过程出错: {str(e)}")


# ====================== 客户端功能 ======================

def recognize_audio(server_url, audio_path, lang_sym="zh"):
    """
    调用ASR API识别音频文件
    
    参数:
        server_url: API服务器地址
        audio_path: 音频文件路径
        lang_sym: 语言代码
    
    返回:
        API响应结果
    """
    # 确认文件存在
    if not os.path.exists(audio_path):
        print(f"错误: 音频文件 '{audio_path}' 不存在")
        return None
    
    # 构建请求URL
    url = f"{server_url.rstrip('/')}/asr-api/asr"
    
    # 构建请求数据
    data = {
        "audio_path": os.path.abspath(audio_path),
        "lang_sym": lang_sym
    }
    
    try:
        # 发送请求
        print(f"正在发送请求: {audio_path}")
        start_time = time.time()
        response = requests.post(url, json=data)
        end_time = time.time()
        
        # 处理响应
        if response.status_code == 200:
            result = response.json()
            
            # 如果是中文，客户端也可以尝试进行繁体到简体的转换
            # 这是为了兼容旧版API服务器
            if lang_sym == "zh" and zhconv is not None:
                result['text'] = convert_traditional_to_simplified(result['text'])
                
            print(f"识别成功! 总请求时间: {end_time - start_time:.4f} 秒")
            print(f"识别结果: {result['text']}")
            print(f"服务器处理时间: {result['duration']:.4f} 秒")
            return result
        else:
            print(f"错误: 状态码 {response.status_code}")
            print(f"错误信息: {response.text}")
            return None
            
    except requests.exceptions.ConnectionError:
        print(f"错误: 无法连接到服务器 {server_url}")
        return None
    except Exception as e:
        print(f"错误: {str(e)}")
        return None


def batch_recognize_folder(server_url, folder_path, lang_sym="zh", recursive=False, file_extensions=None):
    """
    批量处理指定文件夹中的所有音频文件并调用ASR API识别
    
    参数:
        server_url: API服务器地址
        folder_path: 音频文件夹路径
        lang_sym: 语言代码，默认为"zh"（中文）
        recursive: 是否递归处理子文件夹，默认False
        file_extensions: 支持的音频文件扩展名列表，默认为[".wav", ".mp3", ".flac", ".ogg", ".m4a"]
    
    返回:
        results_list: 包含所有识别结果的列表
    """
    if file_extensions is None:
        file_extensions = [".wav", ".mp3", ".flac", ".ogg", ".m4a"]
    
    # 检查文件夹是否存在
    if not os.path.exists(folder_path):
        print(f"错误: 文件夹 '{folder_path}' 不存在")
        return []
    
    # 存储所有识别结果的列表
    results_list = []
    
    # 处理文件的计数器
    total_files = 0
    processed_files = 0
    failed_files = 0
    
    print(f"开始批量处理文件夹: {folder_path}")
    start_total_time = time.time()
    
    # 遍历文件夹
    if recursive:
        # 递归遍历所有子文件夹
        for root, _, files in os.walk(folder_path):
            for filename in files:
                file_path = os.path.join(root, filename)
                file_ext = os.path.splitext(filename)[1].lower()
                
                # 检查是否为支持的音频格式
                if file_ext in file_extensions:
                    total_files += 1
                    result = recognize_audio(server_url, file_path, lang_sym)
                    if result:
                        processed_files += 1
                        results_list.append(result)
                    else:
                        failed_files += 1
    else:
        # 只处理当前文件夹中的文件
        for filename in os.listdir(folder_path):
            file_path = os.path.join(folder_path, filename)
            file_ext = os.path.splitext(filename)[1].lower()
            
            # 检查是否为文件且为支持的音频格式
            if os.path.isfile(file_path) and file_ext in file_extensions:
                total_files += 1
                result = recognize_audio(server_url, file_path, lang_sym)
                if result:
                    processed_files += 1
                    results_list.append(result)
                else:
                    failed_files += 1
    
    # 输出处理统计信息
    end_total_time = time.time()
    total_duration = end_total_time - start_total_time
    
    print("\n批量处理完成!")
    print(f"总文件数: {total_files}")
    print(f"成功处理: {processed_files}")
    print(f"处理失败: {failed_files}")
    print(f"总处理时间: {total_duration:.4f} 秒")
    
    if processed_files > 0:
        print(f"平均每个文件处理时间: {total_duration / processed_files:.4f} 秒")
    
    # 确保所有结果已经进行了繁体到简体的转换
    if lang_sym == "zh" and zhconv is not None:
        for result in results_list:
            if 'text' in result:
                result['text'] = convert_traditional_to_simplified(result['text'])
    
    return results_list

def recognize_audio_file(server_url, audio_file_path, lang_sym="zh"):
    """
    上传音频文件到ASR API并获取识别结果
    
    参数:
        server_url: API服务器地址
        audio_file_path: 音频文件路径
        lang_sym: 语言代码
    
    返回:
        API响应结果
    """
    # 确认文件存在
    if not os.path.exists(audio_file_path):
        print(f"错误: 音频文件 '{audio_file_path}' 不存在")
        return None
    
    # 构建请求URL
    url = f"{server_url.rstrip('/')}/asr-api/asr2"
    
    # 准备上传的文件和表单数据
    files = {
        'audio_file': (os.path.basename(audio_file_path), open(audio_file_path, 'rb'), f'audio/{os.path.splitext(audio_file_path)[1][1:]}')
    }
    data = {
        'lang_sym': lang_sym,
        'device': 'cuda'  # 默认使用CUDA
    }
    
    try:
        # 发送请求
        print(f"正在上传文件: {audio_file_path}")
        start_time = time.time()
        response = requests.post(url, files=files, data=data)
        end_time = time.time()
        
        # 处理响应
        if response.status_code == 200:
            result = response.json()
            
            # 如果是中文，客户端也可以尝试进行繁体到简体的转换
            # 这是为了兼容旧版API服务器
            if lang_sym == "zh" and zhconv is not None:
                result['text'] = convert_traditional_to_simplified(result['text'])
                
            print(f"识别成功! 总请求时间: {end_time - start_time:.4f} 秒")
            print(f"识别结果: {result['text']}")
            print(f"服务器处理时间: {result['duration']:.4f} 秒")
            print(f"文件名: {result['filename']}")
            return result
        else:
            print(f"错误: 状态码 {response.status_code}")
            print(f"错误信息: {response.text}")
            return None
            
    except requests.exceptions.ConnectionError:
        print(f"错误: 无法连接到服务器 {server_url}")
        return None
    except Exception as e:
        print(f"错误: {str(e)}")
        return None
    finally:
        # 确保文件已关闭
        if 'files' in locals() and 'audio_file' in files:
            files['audio_file'][1].close()

def save_results_to_file(results_list, output_path, format="txt"):
    """
    将识别结果保存到文件
    
    参数:
        results_list: 识别结果列表
        output_path: 输出文件路径
        format: 输出格式，目前支持"txt"和"csv"
        
    返回:
        成功返回True，失败返回False
    """
    if not results_list:
        print("警告: 没有结果可保存")
        return False
    
    try:
        if format.lower() == "csv":
            import csv
            with open(output_path, 'w', newline='', encoding='utf-8') as csvfile:
                fieldnames = ['audio_path', 'text', 'duration']
                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
                writer.writeheader()
                for result in results_list:
                    writer.writerow({
                        'audio_path': result.get('audio_path', result.get('filename', 'unknown')),
                        'text': result.get('text', ''),
                        'duration': result.get('duration', 0)
                    })
        else:  # 默认为txt格式
            with open(output_path, 'w', encoding='utf-8') as f:
                for i, result in enumerate(results_list, 1):
                    audio_path = result.get('audio_path', result.get('filename', 'unknown'))
                    text = result.get('text', '')
                    duration = result.get('duration', 0)
                    f.write(f"[{i}] 文件: {audio_path}\n")
                    f.write(f"识别结果: {text}\n")
                    f.write(f"处理时间: {duration:.4f} 秒\n\n")
        
        print(f"结果已保存到: {output_path}")
        return True
        
    except Exception as e:
        print(f"保存结果时出错: {str(e)}")
        return False

    
def batch_process_folder_local(folder_path, lang_sym="zh", device="cuda", recursive=False, file_extensions=None):
    """
    批量处理指定文件夹中的所有音频文件，使用本地模型直接识别
    
    参数:
        folder_path: 音频文件夹路径
        lang_sym: 语言代码，默认为"zh"（中文）
        device: 推理设备，"cuda"或"cpu"
        recursive: 是否递归处理子文件夹，默认False
        file_extensions: 支持的音频文件扩展名列表，默认为[".wav", ".mp3", ".flac", ".ogg", ".m4a"]
    
    返回:
        results_list: 包含所有识别结果的列表
    """
    if file_extensions is None:
        file_extensions = [".wav", ".mp3", ".flac", ".ogg", ".m4a"]
    
    # 检查文件夹是否存在
    if not os.path.exists(folder_path):
        print(f"错误: 文件夹 '{folder_path}' 不存在")
        return []
    
    # 存储所有识别结果的列表
    results_list = []
    
    # 处理文件的计数器
    total_files = 0
    processed_files = 0
    failed_files = 0
    
    print(f"开始批量处理文件夹: {folder_path}")
    start_total_time = time.time()
    
    # 预加载模型（只加载一次）
    model = load_model_once(device=device)
    
    # 遍历文件夹
    if recursive:
        # 递归遍历所有子文件夹
        for root, _, files in os.walk(folder_path):
            for filename in files:
                file_path = os.path.join(root, filename)
                file_ext = os.path.splitext(filename)[1].lower()
                
                # 检查是否为支持的音频格式
                if file_ext in file_extensions:
                    total_files += 1
                    try:
                        print(f"正在处理: {file_path}")
                        file_start_time = time.time()
                        
                        # 直接调用stream_asr函数处理音频
                        result, inference_time = stream_asr(file_path, model=model, lang_sym=lang_sym, device=device)
                        
                        file_end_time = time.time()
                        file_duration = file_end_time - file_start_time
                        
                        # 构建结果对象
                        result_obj = {
                            "text": result.text,
                            "duration": file_duration,
                            "audio_path": file_path,
                            "inference_time": inference_time
                        }
                        
                        print(f"识别成功! 处理时间: {file_duration:.4f} 秒")
                        print(f"识别结果: {result.text}")
                        
                        processed_files += 1
                        results_list.append(result_obj)
                    except Exception as e:
                        print(f"处理文件出错: {str(e)}")
                        failed_files += 1
    else:
        # 只处理当前文件夹中的文件
        for filename in os.listdir(folder_path):
            file_path = os.path.join(folder_path, filename)
            file_ext = os.path.splitext(filename)[1].lower()
            
            # 检查是否为文件且为支持的音频格式
            if os.path.isfile(file_path) and file_ext in file_extensions:
                total_files += 1
                try:
                    print(f"正在处理: {file_path}")
                    file_start_time = time.time()
                    
                    # 直接调用stream_asr函数处理音频，stream_asr内部已经处理了繁体转简体
                    result, inference_time = stream_asr(file_path, model=model, lang_sym=lang_sym, device=device)
                    
                    file_end_time = time.time()
                    file_duration = file_end_time - file_start_time
                    
                    # 构建结果对象
                    result_obj = {
                        "text": result.text,
                        "duration": file_duration,
                        "audio_path": file_path,
                        "inference_time": inference_time
                    }
                    
                    print(f"识别成功! 处理时间: {file_duration:.4f} 秒")
                    print(f"识别结果: {result.text}")
                    
                    processed_files += 1
                    results_list.append(result_obj)
                except Exception as e:
                    print(f"处理文件出错: {str(e)}")
                    failed_files += 1
    
    # 输出处理统计信息
    end_total_time = time.time()
    total_duration = end_total_time - start_total_time
    
    print("\n批量处理完成!")
    print(f"总文件数: {total_files}")
    print(f"成功处理: {processed_files}")
    print(f"处理失败: {failed_files}")
    print(f"总处理时间: {total_duration:.4f} 秒")
    
    if processed_files > 0:
        print(f"平均每个文件处理时间: {total_duration / processed_files:.4f} 秒")
    
    return results_list
    
def detect_language(audio_path, model=None, device="cuda"):
    """
    检测音频语言是中文还是英文
    
    参数:
        audio_path: 音频文件路径
        model: 预加载的模型，如果为None则使用全局模型
        device: 推理设备，"cuda"或"cpu"
    
    返回:
        lang_sym: 检测到的语言代码 ("zh"或"en")
        confidence: 检测置信度
    """
    # 使用全局模型或者传入的模型
    if model is None:
        model = load_model_once(device=device)
    
    # 加载音频
    audio_data = dolphin.load_audio(audio_path)
    
    # 尝试使用中文和英文分别识别
    zh_start_time = time.time()
    zh_result = model(audio_data, lang_sym="zh")
    zh_end_time = time.time()
    
    # 对中文结果进行繁体到简体的转换
    zh_result.text = convert_traditional_to_simplified(zh_result.text)
    
    en_start_time = time.time()
    en_result = model(audio_data, lang_sym="en")
    en_end_time = time.time()
    
    # 简单的语言检测逻辑：比较识别结果的长度和非空字符数量
    # 这里假设正确的语言会产生更多有意义的文本
    zh_text = zh_result.text.strip()
    en_text = en_result.text.strip()
    
    zh_char_count = len([c for c in zh_text if c.strip()])
    en_char_count = len([c for c in en_text if c.strip()])
    
    # 如果英文结果包含大量中文字符，可能是识别错误
    en_chinese_chars = sum(1 for c in en_text if '\u4e00' <= c <= '\u9fff')
    
    # 如果中文结果几乎没有中文字符，可能是英文
    zh_chinese_chars = sum(1 for c in zh_text if '\u4e00' <= c <= '\u9fff')
    
    # 决策逻辑
    if zh_chinese_chars > 0 and zh_chinese_chars / max(1, len(zh_text)) > 0.3:
        # 如果中文识别结果中有较多中文字符，判断为中文
        detected_lang = "zh"
        confidence = zh_chinese_chars / max(1, len(zh_text))
    elif en_chinese_chars < 3 and en_char_count > 0:
        # 如果英文识别结果中几乎没有中文字符，判断为英文
        detected_lang = "en"
        confidence = 1 - (en_chinese_chars / max(1, len(en_text)))
    else:
        # 默认情况，比较两种识别结果的非空字符数量
        if zh_char_count > en_char_count:
            detected_lang = "zh"
            confidence = zh_char_count / max(1, zh_char_count + en_char_count)
        else:
            detected_lang = "en"
            confidence = en_char_count / max(1, zh_char_count + en_char_count)
    
    print(f"语言检测结果: {detected_lang}, 置信度: {confidence:.4f}")
    print(f"中文识别结果: {zh_text}")
    print(f"英文识别结果: {en_text}")
    
    # 返回检测到的语言和对应的识别结果
    if detected_lang == "zh":
        return detected_lang, confidence, zh_result
    else:
        return detected_lang, confidence, en_result
    
if __name__ == "__main__":
    # 如果直接运行此脚本，则作为客户端运行
    # 
    # 使用示例:
    #
    # [API模式]
    # 1. 识别单个音频文件 (本地路径模式):
    #    python dolphin_asr.py --server http://localhost:8000 --audio path/to/audio.wav
    #
    # 2. 识别单个音频文件 (上传模式):
    #    python dolphin_asr.py --server http://localhost:8000 --audio path/to/audio.wav --upload
    #
    # 3. 批量处理文件夹中的音频文件:
    #    python dolphin_asr.py --server http://localhost:8000 --folder path/to/audio_folder
    #
    # 4. 递归处理文件夹及其子文件夹:
    #    python dolphin_asr.py --server http://localhost:8000 --folder path/to/audio_folder --recursive
    #
    # [本地模式]
    # 5. 使用本地模型识别单个音频文件:
    #    python dolphin_asr.py --audio path/to/audio.wav --local
    #
    # 6. 使用本地模型批量处理文件夹:
    #    python dolphin_asr.py --folder path/to/audio_folder --local
    #
    # 7. 使用CPU处理(当CUDA不可用):
    #    python dolphin_asr.py --folder path/to/audio_folder --local --device cpu
    #
    # [输出保存]
    # 8. 保存识别结果到文本文件:
    #    python dolphin_asr.py --folder path/to/audio_folder --local --output results.txt
    #
    # 9. 保存识别结果为CSV格式:
    #    python dolphin_asr.py --folder path/to/audio_folder --local --output results.csv --format csv
    #
    # exit(client_main())
    test_dolphin_asr()